package com.zlk.algorithm.huawei.nowcoder.string;

import java.util.Scanner;

/**
 * @program: algorithm
 * @ClassName HJ65
 * @description:HJ65 查找两个字符串a,b中的最长公共子串
 *
 * 描述
 * 查找两个字符串a,b中的最长公共子串。若有多个，输出在较短串中最先出现的那个。
 * 注：子串的定义：将一个字符串删去前缀和后缀（也可以不删）形成的字符串。请和“子序列”的概念分开！
 *
 * 数据范围：字符串长度
 * 1≤length≤300
 * 进阶：时间复杂度：o(n3方)
 * 空间复杂度：O(n)
 * 输入描述：
 * 输入两个字符串
 *
 * 输出描述：
 * 返回重复出现的字符
 * @author: slfang
 * @create: 2024-12-31 10:07
 * @Version 1.0
 **/
public class HJ65 {


    public static void main(String[] args) {
        Scanner  in = new Scanner(System.in);
        while (in.hasNextLine()){
            String a = in.nextLine();
            String b = in.nextLine();
            System.out.println(longString(a, b));
            //这种情况不好递归，因为是求位置和长度，并不仅仅是长度，应该直接使用动态规划遍历
//            a = a.length()<b.length()?a:b;
//            b = a.length()<b.length()?b:a;
//            int n = a.length();
//            int m = b.length();
//            int[][] dp = new int[n+1][m+1];
//            for (int i = 0; i <=n; i++) {
//                for (int j = 0; j <=m; j++) {
//                    dp[i][j]=-1;
//                }
//            }
//            System.out.println(f(a.toCharArray(), b.toCharArray(), 0, 0,dp));
        }
    }

    // 动态规划
    public static String longString(String str1, String str2) {
        String temp = "";
        // 保证str1是较短字符串
        if (str1.length() > str2.length()) {
            temp = str1;
            str1 = str2;
            str2 = temp;
        }
        int n = str1.length() ;
        int m = str2.length() ;
        //dp[][] 含义以i，j结尾的最大公共子串
        // if(s1[i]==s2[j]) dp[i][j] = dp[i-1][j-1]+1
        // 遍历最大值，以及index位置
        int[][] dp = new int[n+1][m+1];
        int max = 0;
        int endIndex = 0;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= m; j++) {
                //abcdefghijklmnop
                if(str1.charAt(i-1)==str2.charAt(j-1)){
                    dp[i][j]=dp[i-1][j-1]+1;
                    if(dp[i][j]>max){
                        max = dp[i][j];
                        endIndex = i;
                    }
                }
            }
        }
        return str1.substring(endIndex-max,endIndex);
    }





}
